package nb.photoviewer;

import javafx.concurrent.Task;
import javafx.fxml.FXML;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.Node;
import javafx.scene.control.*;
import javafx.scene.image.WritableImage;
import javafx.scene.input.*;
import javafx.scene.layout.*;
import javafx.scene.image.Image;
import javafx.scene.image.ImageView;
import javafx.scene.layout.TilePane;
import javafx.scene.paint.Color;
import javafx.scene.effect.DropShadow;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.nio.file.StandardOpenOption;
import java.util.*;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import javafx.application.Platform;
import javafx.stage.FileChooser;
import javafx.stage.StageStyle;
import javafx.util.Callback;

import javax.imageio.ImageIO;


public class ImageDisplayManager {


    @FXML
    private Button fresh;

    @FXML
    private Button copy;

    @FXML
    private Button paste;

    @FXML
    private Button delete;
    private ImageUtility imageUtility = new ImageUtility();

    private Map<String, Image> imageCache = new HashMap<>(); // 图片缓存

    private TilePane pictureArea;

    // 当前选中的目录，在目录树的点击事件中适当设置这个变量的值
    private File currentDirectory;

    // 一个变量来存储当前选中的图片文件
    private File currentSelectedImage;

    private MainController mainController;

    public ImageView imageView;

    private double currentWidth=100 ;
    private double currentHeight=100;


    // 一个列表来存储图片文件
    private List<File> imageFiles = new ArrayList<>();

    // 一个列表来存储当前选中的图片文件
    private List<File> selectedImages = new ArrayList<>();

    // 添加一个列表来存储所有的ImageView对象
    private List<ImageView> imageViews = new ArrayList<>();

    private TreeView<File> treeView;
    private ContextMenu contextMenu; // 鼠标右键点击时弹出的上下文菜单

    private Background normalBackground = new Background(new BackgroundFill(Color.TRANSPARENT, CornerRadii.EMPTY, Insets.EMPTY));
    // 定义鼠标悬停时的背景
    private Background hoverBackground = new Background(new BackgroundFill(Color.web("#FFFFFF", 0.15), new CornerRadii(7), Insets.EMPTY));
    // 定义鼠标点击后的背景

    private Background clickedBackground = new Background(new BackgroundFill(Color.web("#FFFFFF", 0.3), new CornerRadii(7), Insets.EMPTY));

    private Map<String, BorderPane> uriToBorderPaneMap = new HashMap<>();

    public void setMainController(MainController mainController) {
        this.mainController = mainController;
    }

    public ImageDisplayManager(Button fresh, Button copy, Button delete,Button paste,TilePane pictureArea) {
        this.pictureArea = pictureArea;
        this.contextMenu = createContextMenus(); // 初始化上下文菜单
        this.fresh = fresh;
        this.copy = copy;
        this.delete = delete;
        this.paste = paste;
        setupButtonHandlers();
    }

/*要实现按钮点击等同于执行上下文菜单中的特定动作，
直接在按钮的事件处理器中调用对应的MenuItem的fire()方法来触发其ActionEvent*/
    private void setupButtonHandlers() {

        // 查找特定的菜单项
        MenuItem copyItem = contextMenu.getItems().stream()
                .filter(item -> "复制".equals(item.getText()))
                .findFirst()
                .orElse(null);

        MenuItem deleteItem = contextMenu.getItems().stream()
                .filter(item -> "删除".equals(item.getText()))
                .findFirst()
                .orElse(null);

        MenuItem refreshItem = contextMenu.getItems().stream()
                .filter(item -> "刷新".equals(item.getText()))
                .findFirst()
                .orElse(null);

        MenuItem pasteItem = contextMenu.getItems().stream()
                .filter(item -> "粘贴".equals(item.getText()))
                .findFirst()
                .orElse(null);

        // 为粘贴按钮设置事件处理器
        if (paste != null) {
            paste.setOnAction(event -> pasteItem.fire());
        }

        // 为复制按钮设置事件处理器
        if (copyItem != null) {
            copy.setOnAction(event -> copyItem.fire());
        }

        // 为删除按钮设置事件处理器
        if (deleteItem != null) {
            delete.setOnAction(event -> deleteItem.fire());
        }

        // 为刷新按钮设置事件处理器
        if (refreshItem != null) {
            fresh.setOnAction(event -> refreshItem.fire());
        }
    }



    // 调用这个方法更新当前目录的显示
    public void updateCurrentDirectory(File directory) {
        this.currentDirectory = directory;
        displayImages(directory); // 更新图片显示区
        System.out.println("当前选中的目录是：" + currentDirectory.getAbsolutePath());
    }

    //构造方法，传入TilePane，ImageDisplayManager操控TilePane

    public void displayImages(File directory) {
        pictureArea.getChildren().clear(); // 清空TilePane以前的内容

        imageFiles.clear(); // 清空 imageFiles 列表

        File[] files = ImageUtility.getValidImageFiles(directory);
        if (files != null) {
            Arrays.stream(files).forEach(file -> addImageToTilePane(file));
        }
    }

    private void addImageToTilePane(File imageFile) {
        imageView = new ImageView(new Image(imageFile.toURI().toString(), 110, 110, true, true, true));
        imageView.setUserData(imageFile.toURI().toString()); // 设置用户数据为文件的URI，便于后续的查找和匹配
        imageView.setFitHeight(currentHeight);
        imageView.setFitWidth(currentWidth);
        imageView.setPreserveRatio(true);
        imageView.setEffect(new DropShadow(10.0, 5.0, 5.0, Color.rgb(0, 0, 0, 0.8))); // More noticeable black theme shadow
        Label label = new Label(imageFile.getName());
        label.setMaxWidth(100);
        label.setMaxHeight(30);
        label.setWrapText(true);
        label.setAlignment(Pos.CENTER);
        label.setTextFill(Color.web("#d7d3d3")); // 设置字体颜色为#d7d3d3

        // 使用BorderPane作为组合ImageView和Label的容器...
        BorderPane borderPane = new BorderPane();
        borderPane.setPrefSize(108.5, 130);
        borderPane.setCenter(imageView);
        borderPane.setBottom(label);
        BorderPane.setAlignment(imageView, Pos.CENTER);
        BorderPane.setAlignment(label, Pos.CENTER);
        borderPane.setBackground(new Background(new BackgroundFill(Color.TRANSPARENT, CornerRadii.EMPTY, Insets.EMPTY)));
        // 将图片文件添加到列表中
        imageFiles.add(imageFile);

        addBorderPaneMouseEvents(borderPane);

        // 检查borderPane是否已经存在于pictureArea的子节点列表中
        if (!pictureArea.getChildren().contains(borderPane)) {
            // 若不存在，则添加到pictureArea中
            pictureArea.getChildren().add(borderPane);
        }
    }

    public void zoomIn() {
        // 遍历所有的ImageView对象并分别进行放大
        for (Node node : pictureArea.getChildren()) {
            if (node instanceof BorderPane) {
                BorderPane borderPane = (BorderPane) node;
                ImageView imageView = (ImageView) borderPane.getCenter();

                double currentWidth = imageView.getFitWidth();
                double currentHeight = imageView.getFitHeight();

                imageView.setFitWidth(currentWidth * 1.2); //放大20%
                imageView.setFitHeight(currentHeight * 1.2); //放大20%

                borderPane.setPrefSize(currentWidth * 1.2, currentHeight * 1.2); //同时放大BorderPane的大小

                System.out.println("放大后图片的宽度为：" + imageView.getFitWidth());
                System.out.println("放大后图片的高度为：" + imageView.getFitHeight());
            }
        }
    }


    public void zoomOut() {
        // 遍历所有的ImageView对象并分别进行缩小
        for (Node node : pictureArea.getChildren()) {
            if (node instanceof BorderPane) {
                BorderPane borderPane = (BorderPane) node;
                ImageView imageView = (ImageView) borderPane.getCenter();

                double currentWidth = imageView.getFitWidth();
                double currentHeight = imageView.getFitHeight();

                imageView.setFitWidth(currentWidth * 0.8); //缩小20%
                imageView.setFitHeight(currentHeight * 0.8); //缩小20%

                borderPane.setPrefSize(currentWidth * 0.8, currentHeight * 0.8); //同时缩小BorderPane的大小

                System.out.println("缩小后图片的宽度为：" + imageView.getFitWidth());
                System.out.println("缩小后图片的高度为：" + imageView.getFitHeight());
            }
        }
    }


    private void addBorderPaneMouseEvents(BorderPane borderPane) {
        // 定义背景、添加事件监听器等...
        setBackgroundAndEventHandlers(borderPane);
    }

    public void setTreeView(TreeView<File> treeView) {
        this.treeView = treeView;
    }

    private void  setBackgroundAndEventHandlers(BorderPane borderPane) {

        // 设置BorderPane的初始背景为透明
        borderPane.setBackground(new Background(new BackgroundFill(Color.TRANSPARENT, CornerRadii.EMPTY, Insets.EMPTY)));

        // 定义鼠标未悬停时的背景

        // 用于存储当前BorderPane是否被选中
        final boolean[] isSelected = { false };

        // 添加鼠标悬停属性的监听器
        borderPane.hoverProperty().addListener((obs, wasHovered, isNowHovered) -> {
            if (!isSelected[0]) {
                if (isNowHovered) {
                    borderPane.setBackground(hoverBackground);
                } else {
                    borderPane.setBackground(normalBackground);
                }
            }
        });


        // 在BorderPane上设置拖动检测事件
        borderPane.setOnDragDetected(event -> {
            // 开始拖动手势
            Dragboard db = borderPane.startDragAndDrop(TransferMode.ANY);

            // 创建一个ClipboardContent对象，用来存储拖动过程中的数据
            ClipboardContent content = new ClipboardContent();


            if(selectedImages.size() ==0) {
                // 获取被拖动的图片的文件路径，然后存储在ClipboardContent中
                ImageView imageView = (ImageView) borderPane.getCenter();
                String filePath = (String) imageView.getUserData();
                content.putString(filePath);
                System.out.println("拖动的图片文件路径为：" + filePath);


                selectedImages.clear();  // 清除之前的选中状态

                // 将当前拖动的图片设置为选中状态
                borderPane.setBackground(clickedBackground);
                isSelected[0] = true;
                selectedImages.add(imageFiles.get(pictureArea.getChildren().indexOf(borderPane)));


            } else{
                // 获取被拖动的图片的文件路径，然后存储在ClipboardContent中
                List<File> filesToDrag = new ArrayList<>();
                for (File selectedImage : selectedImages) {
                    filesToDrag.add(selectedImage);
                }
                content.putFiles(filesToDrag);
            }

            // 创建拖拽影像
            ImageView dragView = new ImageView();
            dragView.setImage(((ImageView) borderPane.getCenter()).getImage()); // 假设图片是BorderPane的Center节点
            dragView.setFitWidth(100); // 设置预览图的宽度
            dragView.setFitHeight(100); // 设置预览图的高度
            dragView.setOpacity(0.5); // 设置透明度以增强视觉效果

            db.setDragView(dragView.getImage());

            // 将ClipboardContent对象存储在Dragboard中
            db.setContent(content);

            event.consume();
        });






        // 添加鼠标点击事件监听器
        borderPane.setOnMouseClicked(event -> {
            contextMenu.hide(); // 在左键点击时隐藏上下文菜单
            int index = pictureArea.getChildren().indexOf(borderPane);
            boolean isCtrlDown = event.isControlDown();
            if (event.getButton() == MouseButton.SECONDARY) {
                // 右键点击触发菜单栏
                if (selectedImages.size() <= 1) { // 只有一张图片被选中时才清空并重新设置选中状态
                    pictureArea.getChildren().forEach(child -> {
                        if (child instanceof BorderPane) {
                            ((BorderPane) child).setBackground(normalBackground);
                            ((boolean[]) ((BorderPane) child).getUserData())[0] = false;
                        }
                    });
                    selectedImages.clear();  // 清除之前的选中状态
                    selectedImages.add(imageFiles.get(index));  // 添加当前图片为选中状态
                    borderPane.setBackground(clickedBackground);
                    isSelected[0] = true;
                }
                // 显示上下文菜单

                contextMenu.getItems().forEach(item -> {
                    if (item.getText().equals("刷新")|| item.getText().equals("粘贴")) {
                        item.setDisable(true);
                    } else {
                        item.setDisable(false);
                    }
                });

                contextMenu.show(borderPane, event.getScreenX(), event.getScreenY());


            } else if (event.getButton() == MouseButton.PRIMARY) {
                // 左键
                if (isCtrlDown) {
                    if (isSelected[0]) {
                        // 如果已选中，则取消选中状态
                        selectedImages.clear(); // 清除以前的选中状态
                        borderPane.setBackground(normalBackground);
                        isSelected[0] = false;
                        selectedImages.remove(imageFiles.get(index));
                    } else {
                        // 如果未选中，则设置为选中状态
                        borderPane.setBackground(clickedBackground);
                        isSelected[0] = true;
                        selectedImages.add(imageFiles.get(index));
                    }

                    // 存储选中状态
                    borderPane.setUserData(isSelected);
                } else {
                    // 没有按下 Ctrl 键，清除先前的选择，并设置当前照片为选中状态
                    pictureArea.getChildren().forEach(child -> {
                        if (child instanceof BorderPane) {
                            ((BorderPane) child).setBackground(normalBackground);
                            ((boolean[]) ((BorderPane) child).getUserData())[0] = false;
                        }
                    });
                    selectedImages.clear();  // 清除之前的选中状态
                    selectedImages.add(imageFiles.get(index));  // 添加当前图片为选中状态
                    borderPane.setBackground(clickedBackground);
                    isSelected[0] = true;
                }

                if (index < imageFiles.size()) {
                    currentSelectedImage = imageFiles.get(index);
                }
                System.out.println("当前选中的图片文件是：" + currentSelectedImage.getAbsolutePath());
            }

            if (event.getButton() == MouseButton.PRIMARY && event.getClickCount() == 2) {
                try {
                    mainController.openSlideShowStage(index); // 调用打开幻灯片的方法

                } catch (Exception e) {
                    e.printStackTrace(); // 异常处理
                }
            }

            String imageAttributes = getImageAttributes();
            mainController.attribute.setText(imageAttributes);

        });


        // 存储isSelected标识
        borderPane.setUserData(isSelected);

        // 在TilePane或其父节点上添加点击事件监听器
        pictureArea.getParent().setOnMouseClicked(event -> {
            // 检查点击事件是否发生在TilePane上（即空白处）
            if (event.getTarget()==pictureArea) {
                // 取消所有图片的选中状态
                pictureArea.getChildren().forEach(child -> {
                    if (child instanceof BorderPane) {
                        ((BorderPane) child).setBackground(normalBackground);
                        ((boolean[]) ((BorderPane) child).getUserData())[0] = false;
                    }
                });

                selectedImages.clear();  // 清除选中状态
                String imageAttributes = getImageAttributes();
                mainController.attribute.setText(imageAttributes);

                // 显示上下文菜单，并禁用“复制”等菜单项，只有“刷新”和“粘贴”可以使用
                if (event.getButton() == MouseButton.SECONDARY) {
                    contextMenu.getItems().forEach(item -> {
                        if (item.getText().equals("复制") || item.getText().equals("重命名") || item.getText().equals("删除")) {
                            item.setDisable(true);
                        } else {
                            item.setDisable(false);
                        }
                    });
                    contextMenu.show(pictureArea, event.getScreenX(), event.getScreenY());

                }else{
                     //点击非空白区域时，隐藏上下文菜单,并禁用功能
                    contextMenu.hide();
                }
            }
        });
    }


    public void setCellFactory(TreeView<File> treeView) {
        treeView.setCellFactory(new Callback<TreeView<File>, TreeCell<File>>() {
            @Override
            public TreeCell<File> call(TreeView<File> param) {
                return new TreeCell<File>() {
                    @Override
                    protected void updateItem(File item, boolean empty) {
                        super.updateItem(item, empty);
                        if (empty) {
                            setText(null);
                            setGraphic(null);
                        } else {
                            if (item.getParent() == null) {
                                setText(item.getPath()); // 对于盘符使用 getPath
                            } else {
                                setText(item.getName());
                            }

                            // 加载图标
                            Image image = new Image("file:src/main/resources/nb/photoviewer/img/文件夹.png");
                            ImageView imageView = new ImageView(image);
                            imageView.setFitHeight(17);
                            imageView.setFitWidth(17);

                            // 设置图标
                            setGraphic(imageView);

                            // 设置TreeCell的样式
                            setStyle("-fx-padding: 5px; -fx-font-size: 14px;" +
                                    "-fx-background-color: #202020;"+
                                    "-fx-text-fill:#ffffff,202,202;" +
                                    "-fx-border-color: transparent;");

                            // 移除可能存在的"root-Item"样式类
                            this.getStyleClass().remove("root-Item");

// 用于存储当前目录项是否被点击
                            final boolean[] isClicked = { false };

//                            hoverProperty().addListener((observable, oldValue, newValue) -> {
//                                String text = getText();
//                                if (newValue && text != null && !text.isEmpty()) {
//                                    setStyle("-fx-padding: 5px; -fx-font-size: 14px;" +
//                                            "-fx-background-color: #404040; -fx-text-fill: white;" +
//                                            "-fx-border-color: transparent;");
//                                } else {
//                                    if (isClicked[0]) {
//                                        // 如果目录项被点击过，保持点击后的样式
//                                        setStyle("-fx-padding: 5px; -fx-font-size: 14px;" +
//                                                "-fx-background-color: #404040; -fx-text-fill: white;" +
//                                                "-fx-border-color: transparent;");
//                                    } else {
//                                        setStyle("-fx-padding: 5px; -fx-font-size: 14px;" +
//                                                "-fx-background-color: #202020;"+
//                                                "-fx-text-fill:#ffffff,202,202;" +
//                                                "-fx-border-color: transparent;"); // 非悬停时的样式
//                                    }
//                                }
//                            });

                            setOnMouseClicked(event -> {
                                String text = getText();
                                if (event.getButton() == MouseButton.PRIMARY && text != null && !text.isEmpty()) {
                                    setStyle("-fx-padding: 5px; -fx-font-size: 14px;" +
                                            "-fx-background-color: #404040; -fx-text-fill: white;" +
                                            "-fx-border-color: transparent;");
                                    isClicked[0] = true;
                                }
                            });

// 添加鼠标离开事件处理程序，用于重置点击状态和样式
                            setOnMouseExited(event -> {
                                if (!isClicked[0]) {
                                    setStyle("-fx-padding: 5px; -fx-font-size: 14px;" +
                                            "-fx-background-color: #202020;"+
                                            "-fx-text-fill:#ffffff,202,202;" +
                                            "-fx-border-color: transparent;"); // 非悬停时的样式
                                }
                            });

// 添加点击事件结束时的处理程序，用于重置点击状态
                            setOnMouseReleased(event -> {
                                isClicked[0] = false;
                            });


                            // 监听文本属性的变化
                            textProperty().addListener((observable, oldValue, newValue) -> {
                                if (newValue == null || newValue.isEmpty()) {
                                    setStyle("-fx-padding: 5px; -fx-font-size: 14px;" +
                                            "-fx-background-color: #202020;" +
                                            "-fx-text-fill:#ffffff,202,202;" +
                                            "-fx-border-color: transparent;"); // 非悬停时的样式
                                }
                            });


//                            // 如果当前的TreeItem的名字是"我的电脑"，添加rootItem样式类
//                            if (item.getName().equals("我的电脑")) {
//                                this.getStyleClass().add("root-Item");
//                            }

                            // 设置拖拽事件（悬浮未放下）
                            setOnDragOver(event -> {
                                if (event.getGestureSource() != this &&(event.getDragboard().hasFiles()|| event.getDragboard().hasString())) {
                                    event.acceptTransferModes(TransferMode.COPY_OR_MOVE);
                                }
                                event.consume();
                            });



// 在TreeCell上设置拖拽放下事件
                            setOnDragDropped(event -> {
                                System.out.println("松开鼠标."); // 添加的打印语句
                                // 打印当前的目录项
                                System.out.println("鼠标放下的目录项：" + item.getPath());

                                // 获取目标目录
                                File targetDirectory = this.getTreeItem().getValue();
                                System.out.println("目标目录：" + targetDirectory.getPath());

                                // 获取剪贴板中的文件
                                Clipboard clipboard = Clipboard.getSystemClipboard();

                                if (clipboard.hasString()) {
                                    String content = clipboard.getString();
                                    content=content.substring(content.indexOf('/')+1);
                                    System.out.println("2125"+content);
                                    // 创建目标文件对象
                                    File targetFile = new File(targetDirectory,Path.of(content).getFileName().toString()); // 你可以根据需要更改文件名
                                    try {
                                        // 将字符串内容写入文件
                                            Files.copy(Path.of(content), targetFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
                                        System.out.println("文件已粘贴到：" + targetFile.getPath());
                                    } catch (IOException e) {
                                        e.printStackTrace();
                                        System.out.println("文件粘贴失败。");
                                    }
                                }

                                if (clipboard.hasFiles()) {
                                    List<File> files = clipboard.getFiles();
                                    for (File fileToPaste : files) {
                                        // 创建目标文件对象
                                        File targetFile = new File(targetDirectory, fileToPaste.getName());
                                        try {
                                            // 将字符串内容写入文件
                                            Files.copy(fileToPaste.toPath(), targetFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
                                            System.out.println("文件已粘贴到：" + targetFile.getPath());
                                        } catch (IOException e) {
                                            e.printStackTrace();
                                            System.out.println("文件粘贴失败。");
                                        }
                                    }
                                }
                                event.consume();
                            });






                        }
                    }
                };
            }
        });
    }





    private ContextMenu createContextMenus() {

        if (this.contextMenu == null) {
            this.contextMenu = new ContextMenu();
        }

        // 创建菜单项
        MenuItem copyItem = new MenuItem("复制");
        MenuItem pasteItem = new MenuItem("粘贴");
        MenuItem refreshItem = new MenuItem("刷新");
        MenuItem renameItem = new MenuItem("重命名");
        MenuItem deleteItem = new MenuItem("删除");

        copyItem.setOnAction(event -> {
            // 首先检查selectedImages是否包含文件
            System.out.println("尝试复制以下文件到剪贴板：");
            for (File file : selectedImages) {
                System.out.println(file.getAbsolutePath());
            }
            if (!selectedImages.isEmpty()) {
                Clipboard clipboard = Clipboard.getSystemClipboard();
                ClipboardContent content = new ClipboardContent();
                // 将所有选中的图片文件复制到剪贴板
                content.putFiles(selectedImages);
                clipboard.setContent(content);
                selectedImages.clear();

                System.out.println("文件已复制到剪贴板。");

            } else {
                System.out.println("没有选中的文件要复制。");
            }
        });

        pasteItem.setOnAction(event -> pasteImages());

        deleteItem.setOnAction(event -> {
            // 如果没有选中的图片，则不执行任何操作
            if (selectedImages.isEmpty()) {
                System.out.println("没有选中的文件进行删除。");
                return;
            }
            // 确认删除对话框（简单示例，应实现一个自定义确认对话框）
            Alert alert = new Alert(Alert.AlertType.CONFIRMATION, "确定要删除选中的图片吗？", ButtonType.YES, ButtonType.NO);
            alert.setTitle("删除图片");
            alert.getDialogPane().getStylesheets().add(getClass().getResource("/nb/photoviewer/css/main.css").toExternalForm());
            alert.setHeaderText(null);
            alert.setGraphic(null); // 这行代码会移除对话框的图标

            alert.getDialogPane().getStyleClass().add("deleteItemAlert");

            // 获取YES按钮并添加特定的类名
            Button yesButton = (Button) alert.getDialogPane().lookupButton(ButtonType.YES);
            yesButton.getStyleClass().add("button-yes");

            alert.showAndWait();




            if (alert.getResult() == ButtonType.YES) {

                // 使用并行流遍历所有选中的图片并删除
                selectedImages.parallelStream().forEach(file -> {
                    if (file.exists() && file.delete()) {
                        Platform.runLater(() -> removeImageFromView(file));
                    } else {
                        System.out.println("无法删除文件: " + file.getAbsolutePath());
                    }
                });
                selectedImages.clear();  // 清除选中状态
                updateCurrentDirectory(currentDirectory); // 一次性更新UI
            }
        });

        renameItem.setOnAction(event -> {
            // 这段代码假设用户每次只能重命名一张图片，即 `currentSelectedImage` 是用户当前右键点击的图片
            // 如果您在 UI 中添加了批量重命名的功能，则相应的逻辑应该会有所不同
            if (!selectedImages.isEmpty()) {
                // 单张图片重命名
                if (selectedImages.size() == 1) {
                    File fileToRename = selectedImages.get(0);
                    TextInputDialog dialog = new TextInputDialog(fileToRename.getName());
                    dialog.setTitle("重命名图片");
                    dialog.setHeaderText(null);
                    dialog.setGraphic(null);
                    dialog.setContentText("新的文件名:");

                    dialog.getDialogPane().getStylesheets().add(getClass().getResource("/nb/photoviewer/css/main.css").toExternalForm());
                    dialog.getDialogPane().getStyleClass().add("arenameDialog");

// 获取输入框并设置样式类
                    TextField inputField = dialog.getEditor();
                    inputField.getStyleClass().add("text-field");


// 获取按钮并设置样式类
                    Button okButton = (Button) dialog.getDialogPane().lookupButton(ButtonType.OK);
                    okButton.getStyleClass().add("button-ok");


                    Optional<String> result = dialog.showAndWait();
                    result.ifPresent(newName -> renameImage(fileToRename, newName));
                }
                // 多张图片批量重命名
                // 多张图片批量重命名
                else {
                    Dialog<ButtonType> dialog = new Dialog<>();
                    dialog.setTitle("批量重命名图片");
//                    dialog.setHeaderText("请输入新的文件名前缀，并选择起始编号及编号位数");

                    // 设置批量重命名的表单
                    GridPane grid = new GridPane();
                    grid.setHgap(10);
                    grid.setVgap(10);
                    grid.setPadding(new Insets(20, 150, 10, 10));

                    TextField namePrefixField = new TextField();
                    namePrefixField.setPromptText("");
                    TextField startNumberField = new TextField();
                    startNumberField.setPromptText("");
                    TextField digitField = new TextField();
                    digitField.setPromptText("");

                    grid.add(new Label("前缀:"), 0, 0);
                    grid.add(namePrefixField, 1, 0);
                    grid.add(new Label("起始编号:"), 0, 1);
                    grid.add(startNumberField, 1, 1);
                    grid.add(new Label("编号位数:"), 0, 2);
                    grid.add(digitField, 1, 2);

                    dialog.getDialogPane().setContent(grid);
                    dialog.getDialogPane().getButtonTypes().addAll(ButtonType.OK, ButtonType.CANCEL);

                    dialog.getDialogPane().getStylesheets().add(getClass().getResource("/nb/photoviewer/css/main.css").toExternalForm());
                    dialog.getDialogPane().getStyleClass().add("arenameDialog");

                    Button okButton = (Button) dialog.getDialogPane().lookupButton(ButtonType.OK);
                    okButton.getStyleClass().add("button-ok");

                    Optional<ButtonType> result = dialog.showAndWait();
                    if (result.isPresent() && result.get() == ButtonType.OK) {
                        if (!namePrefixField.getText().isEmpty() && !startNumberField.getText().isEmpty() && !digitField.getText().isEmpty()) {
                            int startNumber = Integer.parseInt(startNumberField.getText());
                            int digits = Integer.parseInt(digitField.getText());
                            batchRenameImages(namePrefixField.getText(), startNumber, digits);
                        }
                    }
                }
            }
        });

        refreshItem.setOnAction(event -> {
            // 刷新当前目录的图片显示
            if (currentDirectory != null && currentDirectory.isDirectory()) {
                displayImages(currentDirectory);
            }
        });

        // 创建上下文菜单并添加菜单项
        this.contextMenu.getItems().addAll(copyItem, pasteItem, refreshItem,renameItem, deleteItem);
        return this.contextMenu;
    }

    //粘贴方法
    public void pasteImages() {
        System.out.println("调用粘贴方法");
        Clipboard clipboard = Clipboard.getSystemClipboard();
        if (clipboard.hasFiles()) {
            List<File> files = clipboard.getFiles();
            for (File fileToPaste : files) {
                // 确保当前目录是存在的
                if (currentDirectory != null && currentDirectory.isDirectory()) {
                    File destFile = new File(currentDirectory, fileToPaste.getName());

                    // 如果目标文件已经存在，重命名新文件
                    String extension = "";
                    int i = fileToPaste.getName().lastIndexOf('.');
                    if (i > 0) {
                        extension = fileToPaste.getName().substring(i);
                    }
                    String baseName = fileToPaste.getName().substring(0, i);

                    int count = 0;
                    while (destFile.exists()) {
                        count++;
                        String newName = baseName + "(" + count + ")" + extension;
                        destFile = new File(currentDirectory, newName);
                    }

                    // 粘贴文件
                    try {
                        Files.copy(fileToPaste.toPath(), destFile.toPath());
                        // 添加到图库显示
                        addImageToTilePane(destFile);
                    } catch (IOException e) {
                        // 处理可能发生的任何异常，例如文件写入权限问题等
                        e.printStackTrace();
                    }
                }
            }
        }
        selectedImages.clear();
    }

    // 删除图片的方法
    private void removeImageFromView(File imageToRemove) {
        // 从画面上移除对应的BorderPane
        pictureArea.getChildren().removeIf(node -> {
            if (node instanceof BorderPane) {
                ImageView imageView = (ImageView)((BorderPane)node).getCenter();
                String url = imageView.getImage().getUrl();
                File file = new File(url);
                return file.equals(imageToRemove);
            }
            return false;
        });
        // 从imageFiles中移除文件
        imageFiles.remove(imageToRemove);
    }

    // 重命名方法
    private void renameImage(File imageToRename, String newName) {
        String extension = ImageUtility.getFileExtension(imageToRename.getName());
        File newFile = new File(imageToRename.getParent(), newName + extension);

        if (imageToRename.renameTo(newFile)) {
            System.out.println("文件重命名成功。");
            updateImageInView(imageToRename, newFile); // 更新UI
        } else {
            System.out.println("文件重命名失败，请检查文件是否打开或者你是否有足够的权限。");
        }
    }

    private void batchRenameImages(String prefix, int startNumber, int digits) {
        // 对selectedImages按照文件名排序，以确保批量重命名的顺序（这只是一种方法，具体需求可能不同）
        selectedImages.sort(Comparator.comparing(File::getName));
        int counter = startNumber;

        for (File file : selectedImages) {
            String number = String.format("%0" + digits + "d", counter++);
            String newName = prefix + number;
            renameImage(file, newName);
        }
        // 重命名后需要更新当前目录的图片显示
        updateCurrentDirectory(currentDirectory);
    }


    public void updateImageInView(File oldFile, File newFile) {
        // 在视图中更新Label和ImageView的显示
        pictureArea.getChildren().forEach(node -> {
            if (node instanceof BorderPane) {
                ImageView imageView = (ImageView) ((BorderPane) node).getCenter();
                Label label = (Label) ((BorderPane) node).getBottom();

                String imageUri = (String) imageView.getUserData(); // 之前设置的用户数据
                File fileFromImageView = new File(imageUri);

                if (fileFromImageView.equals(oldFile)) {
                    imageView.setImage(new Image(newFile.toURI().toString()));
                    imageView.setUserData(newFile.toURI().toString());
                    label.setText(newFile.getName());
                }
            }
        });
        // 更新存储的文件引用
        imageFiles.replaceAll(file -> file.equals(oldFile) ? newFile : file);
        updateCurrentDirectory(currentDirectory);

    }

    public String getImageAttributes() {
        if (imageFiles.isEmpty()) {
            return "";
        }

        long totalSize = 0;
        long selectedSize = 0;
        int totalImages = imageFiles.size();
        int selectedImagesCount = selectedImages.size();

        for (File file : imageFiles) {
            totalSize += file.length();
        }

        for (File file : selectedImages) {
            selectedSize += file.length();
        }

        String totalSizeStr = totalSize < 1024 * 1024 ?
                String.format("%.2f KB", totalSize / 1024.0) :
                String.format("%.2f MB", totalSize / 1024.0 / 1024.0);

        String selectedSizeStr = selectedSize < 1024 * 1024 ?
                String.format("%.2f KB", selectedSize / 1024.0) :
                String.format("%.2f MB", selectedSize / 1024.0 / 1024.0);

        return String.format("共%d张图片(%s) - 选中%d张图片(%s)",
                totalImages, totalSizeStr, selectedImagesCount, selectedSizeStr);
    }

    // 获取图片文件列表的方法，传给幻灯片用
    public List<File> getImageFiles() {
        return imageFiles;
    }




}